home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / DSMODS / FTMGR.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-10  |  18.5 KB  |  827 lines
  1. #include    <stdio.h>
  2. #include    <osbind.h>
  3. #include    <obdefs.h>
  4. #include    <gemdefs.h>
  5. #include    "deskset2.h"
  6. #include    "defs.h"        /* system definitions    */
  7. #include    "comp.h"
  8.  
  9. #define        FALSE        0
  10. #define        TRUE        1
  11.  
  12. #define        SFTSIZ        1548    /* single Font size    */
  13. #define        KDSIZ        484    /* Kern data (121 * 4)    */
  14. #define        KPSIZ        768    /* Kern pair (256 * 3)    */
  15.  
  16. #define        CFNOFS        2    /* Comp/Face # offset    */
  17. #define        TFNOFS        15    /* TpFace Name offset    */
  18. #define        ACCOFS        35    /* Avcc flag   offset    */
  19. #define        KRNOFS        36    /* Kern flag   offset    */
  20. #define        SKROFS        293    /* Std. Kern   offset    */
  21. #define        KPCOFS        777    /* Kpair count offset    */
  22. #define        DKROFS        1549    /* Des. Kern   offset    */
  23.  
  24. #define        SKRset        2    /* Std. Kern bit (2)    */
  25. #define        DKRset        4    /* Des. Kern bit (3)    */
  26. #define        UKRset        8    /* User Kern bit (4)    */
  27.  
  28. extern    char        *get_fp(), *malloc();
  29. extern    unsigned char    ptsfpos[];
  30. extern    int        grvint();
  31. extern    char        fs_iinsel[];
  32.  
  33. struct    dll_type {        /* doubly linked list structure    */
  34.     struct dll_type *fptr;        /* forward pointer    */
  35.     struct dll_type *bptr;        /* backward pointer    */
  36. };
  37. extern    struct    fnt_entry {    /* font index entry definition    */
  38. struct    dll_type link;        /* forward/backward linkages    */
  39.     int    fnt_id;        /* font id (1-9999)        */ 
  40.     char    fnt_name[100];    /* path\filename of font file    */              
  41.     int    rep_id;        /* representative font id    */
  42.     int    rep_pix;    /* pixel size for rep. font    */
  43. }    *fst_idx,        /* pointer to first    entry    */
  44.     *get_entry(),        /* get ptr to entry from UFID    */
  45.     *add_entry();        /* add new entry to index list    */
  46.  
  47. char        nuls[] = "";        /* null string        */
  48. char        sccex[] = ".SCC";    /* font file  extension    */
  49. char        idxex[] = ".IDX";    /* font index extension    */
  50. char        fntdrs[100] = {0};    /* font dress filepath    */
  51. char        fntidx[100] = {0};    /* font index filepath    */
  52.  
  53. char        widpath[100];        /* font WID path    */
  54. unsigned char    fpascii[118];        /* Fpos to Ascii table    */
  55. char        knbuf[64][10];        /* kern pair buffers    */
  56. unsigned    formval;        /* dialog form value    */
  57. char        *ysms, *noms, *kdms1, *kdms2;
  58.  
  59. /*
  60.     Typeface/Font menu handler
  61. */
  62. Fnt_cmd(ch,drsfile)
  63. char    ch, *drsfile;
  64. {
  65.     char    fid[16][6], ukct[16][4];
  66.     char    fidofs, *fidp, *fntp;
  67.     int    dkx, dky, dkw, dkh;
  68.     int    exobj, ftmod, fpmod, newdrs, ifid, err;
  69.     struct    fnt_entry *idxp;
  70.     OBJECT    *ftmenu, *dialog;
  71.  
  72.     rsrc_gaddr(R_STRING,YSMS,&ysms);
  73.     rsrc_gaddr(R_STRING,NOMS,&noms);
  74.     rsrc_gaddr(R_STRING,KDMS1,&kdms1);
  75.     rsrc_gaddr(R_STRING,KDMS2,&kdms2);
  76.     if (ch == 'D') {
  77.       if (!ftin)
  78.         do_alert(NFONT);
  79.       else {
  80.         rsrc_gaddr(0,FONTMAN,&ftmenu);
  81.         ftmenu[FTADD].ob_state    = DISABLED;
  82.         ftmenu[FTDEL].ob_state    = DISABLED;
  83.         ftmenu[FTNPA].ob_state    = DISABLED;
  84.         ftmenu[FTNID].ob_state    = DISABLED;
  85.         ftmenu[FTKCOP].ob_state    = DISABLED;
  86.         ftmenu[FTKMOD].ob_state    = DISABLED;
  87.         ftmenu[FTKDEL].ob_state    = DISABLED;
  88.         dsp_fnt(0,ftmenu,fid,ukct);
  89.         ftmenu[execform(ftmenu,0)].ob_state = NORMAL;
  90.       }
  91.     }
  92.     else
  93.     if (ch == 'L') {
  94.         if (!ld_dress(drsfile,1)) {
  95.             rsrc_gaddr(0,FTCREAT,&dialog);
  96.             dialog[FTCFN].ob_spec    = (long)drsfile;
  97.             exobj = execform(dialog,0);
  98.             dialog[exobj].ob_state = NORMAL;
  99.             if (exobj == FTCOK) {
  100.               memset(ftlib,0,FTSIZ);
  101.               strcpy(fntdrs,drsfile);
  102.               IF_close();
  103.               IF_open(1);
  104.               *fntidx = 0;
  105.               ftin      = false;
  106.               newdrs  = true;
  107.               goto mdf;
  108.             }
  109.             else    return(0);
  110.         }
  111.         return(1);
  112.     }
  113.     else
  114.     if (ch == 'M') {
  115.         newdrs = false;
  116. mdf:        ftmod = fpmod = false;
  117.         rsrc_gaddr(R_TREE,FONTMAN,&ftmenu);
  118.         ftmenu[FTDEL].ob_state    = !IFerr ? NORMAL:DISABLED;
  119.         ftmenu[FTNPA].ob_state    = !IFerr ? NORMAL:DISABLED;
  120.         ftmenu[FTNID].ob_state    = !IFerr ? NORMAL:DISABLED;
  121.         ftmenu[FTKCOP].ob_state    = NORMAL;
  122.         ftmenu[FTKMOD].ob_state    = NORMAL;
  123.         ftmenu[FTKDEL].ob_state    = NORMAL;
  124.         form_center(ftmenu,&dkx,&dky,&dkw,&dkh);
  125.         form_dial(0,0,0,0,0,dkx,dky,dkw,dkh);
  126.         form_dial(1,0,0,0,0,dkx,dky,dkw,dkh);
  127.         do {
  128.           dsp_fnt(1,ftmenu,fid,ukct);
  129.           objc_draw(ftmenu,0,10,dkx,dky,dkw,dkh);
  130.           exobj = form_do(ftmenu,0);
  131.           if (exobj != FTOK && exobj != FTADD &&
  132.              !whichSEL(ftmenu,&fidofs,FID1,FID16))
  133.             do_alert(SFNMS);
  134.           else {
  135.             fntp = ftlib + (fidofs * SFTSIZ);
  136.             fidp = fid[fidofs];
  137.             switch(exobj) {
  138.             case FTADD:
  139.             form_dial(2,0,0,0,0,dkx,dky,dkw,dkh);
  140.             form_dial(3,0,0,0,0,dkx,dky,dkw,dkh);
  141.             BWredraw();            /* redraw TW/PW    */
  142.             if (addfont())
  143.                 ftmod = fpmod = true;
  144.             break;
  145.             case FTDEL:
  146.             if (idxp = get_entry(*(int *)fntp))
  147.                 del_entry(idxp);
  148.             f_move(fntp+SFTSIZ,fntp,(15 - fidofs) * SFTSIZ);
  149.             memset(ftlib+FTSIZ-SFTSIZ,0,SFTSIZ);
  150.             ftmod = fpmod = true;
  151.             break;
  152.             case FTNPA:
  153.             if (npafont(fntp,fidp))
  154.                 fpmod = true;
  155.             break;
  156.             case FTNID:
  157.             if (nidfont(fntp,fidp))
  158.                 ftmod = fpmod = true;
  159.             break;
  160.             case FTKCOP:
  161.             if (copykrnpr(fntp,fidp))
  162.                 ftmod = true;
  163.             break;
  164.             case FTKMOD:
  165.             if (modkrnpr(    fntp,ftmenu[FTF1+fidofs].ob_spec,
  166.                     fidp,ftmenu[FKRN1+fidofs].ob_spec  ))
  167.                 ftmod = true;
  168.             break;
  169.             case FTKDEL:
  170.             *(fntp+KRNOFS) &= ~UKRset;    /* No user kern    */
  171.             memset(fntp+KPCOFS,0,KPSIZ+2);
  172.             ftmod = true;
  173.             break;
  174.             }
  175.           }
  176.           ftmenu[exobj].ob_state = NORMAL;
  177.         } while (exobj != FTOK);
  178.         form_dial(2,0,0,0,0,dkx,dky,dkw,dkh);
  179.         form_dial(3,0,0,0,0,dkx,dky,dkw,dkh);
  180.         BWredraw();                /* redraw TW/PW    */
  181.         if (ftmod) {
  182.           exobj = do_alert(FONTSAVE);
  183.           if (exobj == 3) {
  184.             if (gdosfname(drsfile,0,0)) {
  185.                 strcpy(fntdrs,drsfile);
  186.                 fpmod = true;
  187.                 exobj = 1;
  188.             }
  189.             else    fpmod = false;
  190.           }
  191.           if (exobj == 1) {
  192.             err = 0;
  193.             if ((ifid = creat(drsfile,NWFIL)) < 0) ++err;
  194.             else {
  195.                 if (write(ifid,ftlib,FTSIZ) < 0) ++err;
  196.                 close(ifid);
  197.             }
  198.             if (err) setnfd(fntdrs,3);
  199.           }
  200.           setftin();
  201.         }
  202.         if (fpmod) {
  203.           setidxf(drsfile);
  204.           if (newdrs || do_alert(FIDSAVE) == 1)
  205.             writeftidx();
  206.         }
  207.         if (newdrs && !ftmod && !fpmod) {
  208.             setp.ftdrs[0] = *fntdrs = 0;
  209.             return(0);
  210.         }
  211.         return(1);
  212.     }
  213. }
  214.  
  215. /*
  216.     Load Font Dress file
  217. */
  218. ld_dress(drsfile,mod)
  219. char *drsfile;
  220. int mod;
  221. {
  222.     char    *drsbuf, fpath[100];
  223.     int    fid;
  224.     int    err = 0;
  225.  
  226.     if (mod)                /* setup Dress path    */
  227.         strcpy(fpath,drsfile);
  228.     else    findfile(drsfile,fpath);
  229.     if (!strcmp(fntdrs,fpath))        /* same as current...    */
  230.         goto done;
  231.     if (!(drsbuf = malloc(FTSIZ))) {    /* get Dress buffer    */
  232.         do_alert(DRLDERR);
  233.         err = 3;
  234.     }
  235.     else
  236.     if ((fid = open(fpath,FREAD)) <= 0)
  237.         setnfd(drsfile,err = 1);
  238.     else
  239.     if (read(fid,drsbuf,FTSIZ) != FTSIZ)
  240.         setnfd(drsfile,err = 2);
  241.     else {
  242.         f_move(drsbuf,ftlib,FTSIZ);
  243.         setftin();
  244.         strcpy(fntdrs,fpath);
  245.         setidxf(fpath);
  246.         IF_close();
  247.         IF_open(0);
  248.     }
  249.     if (fid > 0) close(fid);
  250.     if (drsbuf) free(drsbuf);
  251. done:    return(!err);
  252. }
  253.  
  254. dsp_fnt(mod,ftbx,fid,ukct)
  255. int    mod;
  256. OBJECT    *ftbx;
  257. char    fid[16][6], ukct[16][4];
  258. {
  259.     char    *ftp, krn;
  260.     int    i, *ftn, free;
  261.  
  262.     free = false;
  263.     for    (ftn = (int *)ftlib,ftp = ftlib,i = 0;
  264.         i < 16;
  265.         ftn += (SFTSIZ / 2),ftp += SFTSIZ,++i)
  266.     if (*ftn) {
  267.         ftbx[FID1+i].ob_state    = mod ? NORMAL:DISABLED;
  268.         utoa(fid[i],*ftn,1000);
  269.         ftbx[FID1+i].ob_spec    = (long)fid[i];
  270.         ftbx[FCF1+i].ob_spec    = (long)(ftp+CFNOFS);
  271.         ftbx[FTF1+i].ob_spec    = (long)(ftp+TFNOFS);
  272.         ftbx[FCC1+i].ob_spec    = (long)((*(ftp+ACCOFS) & 1)
  273.                         ? ysms:noms);
  274.         krn = *(ftp+KRNOFS) & 14;
  275.         if (krn & SKRset)
  276.             ftbx[FKRN1+i].ob_spec    = (long)kdms1;
  277.         else
  278.         if (krn & DKRset)
  279.             ftbx[FKRN1+i].ob_spec    = (long)kdms2;
  280.         else    ftbx[FKRN1+i].ob_spec    = (long)noms;
  281.         if (krn & UKRset) {
  282.             utoa(ukct[i],get_argument(ftp+KPCOFS),100);
  283.             ftbx[FUK1+i].ob_spec    = (long)ukct[i];
  284.         }
  285.         else    ftbx[FUK1+i].ob_spec    = (long)noms;
  286.     }
  287.     else {
  288.         ftbx[FID1+i].ob_state    = DISABLED;
  289.         ftbx[FID1+i].ob_spec    = (long)nuls;
  290.         ftbx[FCF1+i].ob_spec    = (long)nuls;
  291.         ftbx[FTF1+i].ob_spec    = (long)nuls;
  292.         ftbx[FCC1+i].ob_spec    = (long)nuls;
  293.         ftbx[FKRN1+i].ob_spec    = (long)nuls;
  294.         ftbx[FUK1+i].ob_spec    = (long)nuls;
  295.         free = true;
  296.     }
  297.     if (mod)
  298.         ftbx[FTADD].ob_state    = (free && !IFerr) ? NORMAL:DISABLED;
  299. }
  300.  
  301. addfont()
  302. {
  303.     char    npath[100], idbuf[6], fc[8], ff[8];
  304.     int    ifid, ufid, done, exobj;
  305.     char    *fbuf, krn, *nftp;
  306.     struct    fnt_entry *idxp;
  307.     OBJECT    *dialog;
  308.  
  309.     done = false;
  310.     if (gdosfname(npath,3,1)) {
  311.       fbuf    = malloc(SFTSIZ+KDSIZ);        /* get Font buffer    */
  312.       ifid    = -1;
  313.       if  (    !fbuf    ||
  314.         (ifid = open(npath,FREAD))    <= 0 ||
  315.         read(ifid,fbuf,SFTSIZ+KDSIZ)    <= 0 )
  316.         setnfd(fs_iinsel,2);
  317.       else {
  318.         f_move(fbuf+CFNOFS  ,fc,6);    fc[6] = 0;
  319.         f_move(fbuf+CFNOFS+6,ff,6);    ff[6] = 0;
  320.         idbuf[0] = 0;
  321.         strunc(npath);    strcat(npath,sccex);
  322.         rsrc_gaddr(R_TREE,FONTADD,&dialog);
  323.         ((TEDINFO *)dialog[FTPATH2].ob_spec)->te_ptext    = npath;
  324.         ((TEDINFO *)dialog[FADDID].ob_spec)->te_ptext    = idbuf;
  325.         dialog[FADDFC].ob_spec    = (long)fc;
  326.         dialog[FADDFF].ob_spec    = (long)ff;
  327.         dialog[FADDFN].ob_spec    = (long)(fbuf+TFNOFS);
  328.         dialog[FADDCC].ob_spec    = (long)((*(fbuf+ACCOFS) & 1)
  329.                         ? ysms:noms);
  330.         krn = *(fbuf+KRNOFS) & 6;
  331.         if (krn & SKRset) {
  332.             dialog[FADDNK].ob_state = DISABLED;
  333.             dialog[FADDSK].ob_state = SELECTED;
  334.             dialog[FADDDK].ob_state = (krn & DKRset)
  335.                         ? NORMAL:DISABLED;
  336.         }
  337.         else
  338.         if (krn & DKRset) {
  339.             dialog[FADDNK].ob_state = DISABLED;
  340.             dialog[FADDSK].ob_state = DISABLED;
  341.             dialog[FADDDK].ob_state = SELECTED;
  342.         }
  343.         else {
  344.             dialog[FADDNK].ob_state = SELECTED;
  345.             dialog[FADDSK].ob_state = DISABLED;
  346.             dialog[FADDDK].ob_state = DISABLED;
  347.         }
  348.         formval = 0;
  349.         dial1(dialog);
  350.         do {
  351.           exobj = dial2(dialog);
  352.           if (exobj == FADDOK) {
  353.             if (access(npath,0)) {
  354.                 formval = FTPATH2;
  355. err:                do_alert(BADINP);
  356.                 continue;
  357.             }
  358.             ufid = *idbuf ? atoi(idbuf):0;
  359.             if (ufid && !get_fp(ufid) && !get_entry(ufid)) {
  360.               if (!(idxp = add_entry(fst_idx))) {
  361.                 do_alert(NFNTERR);
  362.                 break;
  363.               }
  364.               strcpy(idxp->fnt_name,npath);
  365.               idxp->rep_id    = idxp->rep_pix = 0;
  366.               idxp->fnt_id    = ufid;
  367.               *(int *)fbuf    = ufid;
  368.               nftp = get_fp(0);
  369.               if (krn == 6) {
  370.                 if (dialog[FADDDK].ob_state & SELECTED) {
  371.                  f_move(fbuf+DKROFS,fbuf+SKROFS,KDSIZ);
  372.                  *(fbuf+KRNOFS) &= ~SKRset;
  373.                 }
  374.                 else *(fbuf+KRNOFS) &= ~DKRset;
  375.               }
  376.                     /* swap Reverse Video values..    */
  377.               sav_argument(fbuf+45,grvint(fbuf+45));
  378.               sav_argument(fbuf+47,grvint(fbuf+47));
  379.               sav_argument(fbuf+49,grvint(fbuf+49));
  380.                     /* save Font to dress buffer..    */
  381.               f_move(fbuf,nftp,SFTSIZ);
  382.               done = true;
  383.             }
  384.             else {
  385.                 formval = FADDID;
  386.                 goto err;
  387.             }
  388.             break;
  389.           }
  390.         } while (exobj != FADDNOK);
  391.         dial3();
  392.       }
  393.       if (ifid > 0) close(ifid);
  394.       if (fbuf) free(fbuf);
  395.     }
  396.     return(done);
  397. }
  398.  
  399. npafont(fntp,fidp)
  400. char    *fntp, *fidp;
  401. {
  402.     struct    fnt_entry *idxp;
  403.     int    done;
  404.     char    npath[100];
  405.     OBJECT    *dialog;
  406.     int    exobj;
  407.  
  408.     if (!(idxp = get_entry(*(int *)fntp)))
  409.         return(0);
  410.     strcpy(npath,idxp->fnt_name);
  411.  
  412.     rsrc_gaddr(R_TREE,FNWPA,&dialog);
  413.     dialog[FNPAID].ob_spec    = (long)fidp;
  414.     ((TEDINFO *)dialog[FTPATH1].ob_spec)->te_ptext = npath;
  415.     done = false;
  416.     formval = 0;
  417.     dial1(dialog);
  418.     if ((exobj = dial2(dialog)) == FNPAOK) {
  419.         if (!access(npath,0)) {
  420.             strcpy(idxp->fnt_name,npath);
  421.             done = true;
  422.         }
  423.         else    do_alert(BADINP);
  424.     }
  425.     dial3();
  426.     return(done);
  427. }
  428.  
  429. nidfont(fntp,fidp)
  430. char    *fntp, *fidp;
  431. {
  432.     struct    fnt_entry *idxp;
  433.     char    idbuf[6];
  434.     int    nfid, ofid, done;
  435.     OBJECT    *dialog;
  436.     int    exobj;
  437.  
  438.     ofid = *(int *)fntp;
  439.     if (!(idxp = get_entry(ofid)))
  440.         return(0);
  441.     rsrc_gaddr(R_TREE,FNWID,&dialog);
  442.     dialog[OFID].ob_spec    = (long)fidp;
  443.     ((TEDINFO *)dialog[NWID].ob_spec)->te_ptext = idbuf;
  444.     idbuf[0] = 0;
  445.     done = false;
  446.     formval = 0;
  447.     dial1(dialog);
  448.     if ((exobj = dial2(dialog)) == FNIDOK &&
  449.          *idbuf && (nfid = atoi(idbuf)) != ofid) {
  450.         if (nfid && !get_fp(nfid) && !get_entry(nfid)) {
  451.             idxp->fnt_id    = nfid;
  452.             *(int *)fntp    = nfid;
  453.             done = true;
  454.         }
  455.         else    do_alert(BADINP);
  456.     }
  457.     dial3();
  458.     return(done);
  459. }
  460.  
  461. modkrnpr(krnp,fnmp,fidp,fktp)
  462. char    *krnp, *fnmp, *fidp, *fktp;
  463. {
  464.     char    ctbuf[64][4];
  465.     int    i, j, k, exit_val, cnt;
  466.     int    kpmod;
  467.     char    *kpsave, *knptr, *ptr, buf[4];
  468.     OBJECT    *dialog;
  469.  
  470.     rsrc_gaddr(R_TREE,KERNPAIR,&dialog);
  471.     dialog[KPFNM].ob_spec    = (long)fnmp;
  472.     dialog[KPFID].ob_spec    = (long)fidp;
  473.     dialog[KPFKT].ob_spec    = (long)fktp;
  474.     for (i = 0,j = KPN1,k = KPR1;i < 64;++i,++j,++k) {
  475.       dialog[j].ob_spec    = (long)ctbuf[i];
  476.       ((TEDINFO *)dialog[k].ob_spec)->te_ptext = knbuf[i];
  477.     }
  478.     dialog[KPPRV].ob_state    = DISABLED;
  479.     dialog[KPNXT].ob_state    = NORMAL;
  480.     krnp    += (KPCOFS+2);
  481.     knptr    = krnp;
  482.     cnt    = 1;            /* start at 1, go 65..129..193    */
  483.     kpmod    = false;
  484.     if (!(kpsave = malloc(KPSIZ)))        /* get save Kp buffer    */
  485.         do_alert(MKRNERR);
  486.     else {
  487.       f_move(krnp,kpsave,KPSIZ);
  488.       formval = 0;
  489.       dial1(dialog);
  490.       do {
  491.         for (i = 0,k = cnt,ptr = knptr;i < 64;++i,++k) {
  492.             utoa(ctbuf[i],k,100);
  493.             if (*ptr) {
  494.               buf[3] = 0;
  495.               gkrn_ch(*(ptr++),buf);
  496.               strcpy(knbuf[i],buf);
  497.               gkrn_ch(*(ptr++),buf);
  498.               strcat(knbuf[i],buf);
  499.               gkrn_val(*(ptr++),buf);
  500.               strcat(knbuf[i],buf);
  501.             }
  502.             else {
  503.               knbuf[i][0] = 0;
  504.               ptr += 3;
  505.             }
  506.         }
  507. di:        exit_val = dial2(dialog);
  508.         switch (exit_val) {
  509.         case KPNXT:
  510.             if (save_knval(krnp,knptr)) goto di;
  511.             if (cnt < 256) {
  512.               cnt   += 64;
  513.               knptr += 192;
  514.             }
  515.             break;
  516.         case KPPRV:
  517.             if (save_knval(krnp,knptr)) goto di;
  518.             if (cnt > 64) {
  519.               cnt   -= 64;
  520.               knptr -= 192;
  521.             }
  522.             break;
  523.         case KPOK:
  524.             if (save_knval(krnp,knptr)) goto di;
  525.             kpmod = memcmp(kpsave,krnp,KPSIZ);
  526.             break;
  527.         case KPNOK:
  528.             f_move(kpsave,krnp,KPSIZ);
  529.             break;
  530.         }
  531.         dialog[exit_val].ob_state &= ~SELECTED;
  532.         if (cnt > 1)
  533.             dialog[KPPRV].ob_state &= ~DISABLED;
  534.         else    dialog[KPPRV].ob_state |= DISABLED;
  535.         if (cnt < 193)
  536.             dialog[KPNXT].ob_state &= ~DISABLED;
  537.         else    dialog[KPNXT].ob_state |= DISABLED;
  538.       } while (exit_val != KPOK && exit_val != KPNOK);
  539.       dial3();
  540.       BWredraw();                /* redraw TW/PW    */
  541.       free(kpsave);
  542.     }
  543.     return(kpmod);
  544. }
  545.  
  546. copykrnpr(srcptr,fidp)
  547. char    *srcptr, *fidp;
  548. {
  549.     char    destbuf[6], *destptr;
  550.     int    destid, done;
  551.     OBJECT    *dialog;
  552.     int    exobj;
  553.  
  554.     rsrc_gaddr(R_TREE,FKCOPY,&dialog);
  555.     dialog[FKCPOID].ob_spec    = (long)fidp;
  556.     ((TEDINFO *)dialog[FKCPNID].ob_spec)->te_ptext = destbuf;
  557.     destbuf[0] = 0;
  558.     done = false;
  559.     formval = 0;
  560.     dial1(dialog);
  561.     if ((exobj = dial2(dialog)) == FKCPOK && *destbuf) {
  562.         destid = atoi(destbuf);
  563.         if (destid && (destptr = get_fp(destid))) {
  564.           f_move(srcptr+KPCOFS,destptr+KPCOFS,KPSIZ+2);
  565.           if (*(srcptr+KRNOFS) & UKRset)    /* Kpairs ?    */
  566.             *(destptr+KRNOFS) |=  UKRset;    /* ok bit 3 on    */
  567.           else    *(destptr+KRNOFS) &= ~UKRset;    /* no bit 3 off    */
  568.           done = true;
  569.         }
  570.         else    do_alert(BADINP);
  571.     }
  572.     dial3();
  573.     return(done);
  574. }
  575.  
  576. bld_flash()
  577. {
  578.     int    i;
  579.     memset(fpascii,0xff,118);
  580.     for (i = 0;i < 256;++i)
  581.         if (ptsfpos[i] < 0xfe) fpascii[ ptsfpos[i]-1 ] = i;
  582. }
  583.  
  584. char    *get_fp(ftid)
  585. int    ftid;
  586. {
  587.     int    i, *ftn;
  588.  
  589.     for (ftn = (int *)ftlib,i = 0;i < 16;ftn += (SFTSIZ / 2),++i)
  590.         if (*ftn == ftid) return((char *)ftn);
  591.     return(0L);
  592. }
  593.  
  594.  
  595. gkrn_ch(fp,buf)
  596. char    fp, *buf;
  597. {
  598.     unsigned char     c;
  599.     
  600.     if ((c = fpascii[fp-1]) == 0xff)
  601.         utoa(buf,fp,100);
  602.     else {
  603.         *buf++ = c;
  604.         strcpy(buf,"  ");
  605.     }
  606. }
  607.  
  608. gkrn_val(val,buf)
  609. char    val, *buf;
  610. {
  611.     if (val < 0) {
  612.         buf[0] = '-';
  613.         val = ~val + 1;
  614.     }
  615.     else    buf[0] = '+';
  616.     utoa(buf+1,val,10);
  617. }
  618.  
  619. save_knval(krnp,knptr)
  620. char    *krnp, *knptr;
  621. {
  622.     int    i, j, krncnt;
  623.     char    *ptr;
  624.  
  625.     for (i = 0;i < 64;++i) {
  626.         if (form_krnbuf(knbuf[i],knptr)) {
  627.             do_alert(BADINP);
  628.             formval = KPR1 + i;
  629.             return(1);
  630.         }
  631.         if (knbuf[i][0])
  632.             knptr += 3;
  633.         else    *knptr = *(knptr+1) = *(knptr+2) = 0;
  634.     }
  635.     krncnt = 0;
  636.     for (i = 0,ptr = knptr = krnp;i < 256;++i) {
  637.         if (*ptr && *(ptr+1)) {
  638.             ++krncnt;
  639.             if (ptr != knptr)
  640.             for (j = 0;j < 3;++j) {
  641.                 *knptr++ = *ptr;
  642.                 *ptr++     = 0;
  643.             }
  644.             else {
  645.                 knptr    += 3;
  646.                 ptr    += 3;
  647.             }
  648.         }
  649.         else    ptr += 3;
  650.     }
  651.     while (knptr <= ptr) *knptr++ = 0;
  652.     sav_argument(krnp-2,krncnt);
  653.     krnp    -= 743;
  654.     if (krncnt)                    /* Kpairs ?    */
  655.         *krnp |=  UKRset;            /* ok bit 3 on    */
  656.     else    *krnp &= ~UKRset;            /* no bit 3 off    */
  657.     return(0);
  658. }
  659.  
  660. form_krnbuf(sbuf,kbuf)
  661. char    *sbuf, *kbuf;
  662. {
  663.     char    buf[4];
  664.  
  665.     if (*sbuf) {
  666.         buf[3] = 0;
  667.         strncpy(buf,sbuf,3);
  668.         if (form_knch(buf,kbuf)) return(1);
  669.         strncpy(buf,sbuf+3,3);
  670.         if (form_knch(buf,kbuf+1)) return(1);
  671.         strncpy(buf,sbuf+6,3);
  672.         if (form_knval(buf,kbuf+2)) return(1);
  673.     }
  674.     return(0);
  675. }
  676.  
  677. form_knch(sbuf,kbuf)
  678. char    *sbuf, *kbuf;
  679. {
  680.     char    fp, erf = 0;
  681.  
  682.     if (*(sbuf+1) == ' ' && *(sbuf+2) == ' ') {
  683.         if ((*kbuf = ptsfpos[*sbuf]) == 0xff)
  684.            erf = 1;
  685.     }
  686.     else {
  687.         if (digitbuf(sbuf) &&
  688.            (fp = atoi(sbuf)) < 122 &&
  689.             fp > 0)
  690.             *kbuf = fp;
  691.         else    erf = 1;
  692.     }
  693.     return(erf);
  694. }
  695.  
  696. form_knval(sbuf,kbuf)
  697. char    *sbuf, *kbuf;
  698. {
  699.     char val = 0, fg = 1, erf = 0;
  700.  
  701.     if (*sbuf) {
  702.         if (*(sbuf) == '-') {
  703.             fg = -1;
  704.             ++sbuf;
  705.         }
  706.         else
  707.         if (*(sbuf) == '+')
  708.             ++sbuf;
  709.         if (!digitbuf(sbuf) ||
  710.            (val = atoi(sbuf)) > 32)
  711.             erf = 1;
  712.         else    val *= fg;
  713.     }
  714.     *kbuf = val;
  715.     return(erf);
  716. }
  717.  
  718. sav_argument(valp,value)
  719. unsigned char    *valp;
  720. unsigned    value;
  721. {
  722.     union {
  723.     unsigned char    byt[2];
  724.     unsigned    val;
  725.     } w;
  726.     w.val    = value;
  727.     *valp++    = w.byt[0],
  728.     *valp    = w.byt[1];
  729. }
  730.  
  731. digitbuf(buf)
  732. char    *buf;
  733. {
  734.     while (*buf)
  735.         if (!cdigit(*buf++)) return(0);
  736.     return(1);
  737. }
  738.  
  739. /*
  740.     Write out new Font Dress index file
  741. */
  742. writeftidx()
  743. {
  744.     struct    fnt_entry *idxp;
  745.     FILE    *utf;
  746.  
  747.     setidxf(fntdrs);
  748.     if (!(utf = fopen(fntidx,"w")))        /* Open font idx file    */
  749.         setnfd(fntidx,3);
  750.     else
  751.     if (fst_idx) for (idxp = fst_idx; ;) {
  752.       if (idxp->fnt_id)
  753.         fprintf(utf,"%04d %s %04d %d\n",    /* Write each entry...    */
  754.         idxp->fnt_id,            /* font id (1-9999)    */
  755.         idxp->fnt_name,            /* font path\filename    */
  756.         idxp->rep_id,            /* rep. font id        */
  757.         idxp->rep_pix);            /* pix. size for rep.    */
  758.       if ((struct fnt_entry *)idxp->link.fptr == fst_idx)
  759.         break;
  760.       else    idxp = (struct fnt_entry *)idxp->link.fptr;
  761.     }
  762.     if (utf) fclose(utf);            /* Close font idx file    */
  763. }
  764.  
  765. setidxf(drsfile)
  766. char    *drsfile;
  767. {
  768.     strcpy(fntidx,drsfile);
  769.     strunc(fntidx);
  770.     strcat(fntidx,idxex);
  771. }
  772.  
  773. setftin()
  774. {
  775.     ftin    = true;
  776.     pftpt    = ftlib;        /* reset font pointer    */
  777. }
  778.  
  779. IF_close()
  780. {
  781.     if (!(IFerr & 4)) fm_close();
  782. }
  783.  
  784. IF_open(mod)
  785. int    mod;
  786. {
  787.     if (!(IFerr & 3)) {
  788.       if (initftsys(mod)) {        /* setup Intellifont    */
  789.         do_alert(PMS0);
  790.         IFerr |= 4;
  791.       }
  792.       else {
  793.         IFerr &= ~4;
  794.         if (fst_idx) {
  795.             strcpy(widpath,fst_idx->fnt_name);
  796.             filetopath(widpath);
  797.         }
  798.       }
  799.     }
  800. }
  801.  
  802. grvint(ptr)
  803. unsigned char    *ptr;
  804. {
  805.     unsigned wrd;
  806.     wrd    = *(ptr+1);
  807.     wrd    <<= 8;
  808.     wrd    &= 0xff00;
  809.     wrd    |= *ptr;
  810.     return(wrd);
  811. }
  812.  
  813. ckfont(ID)
  814. int    ID;
  815. {
  816.     unsigned char    *ftp;
  817.  
  818.     if (ftp = get_fp(ID)) {
  819.         pftpt = ftp;
  820.         loadavcc();
  821.         ldacmp();
  822.         if (avcval) avcval = acmp;
  823.         return(1);
  824.     }
  825.     else    return(0);
  826. }
  827.